﻿#ifndef TGSDKMANAGER_H
#define TGSDKMANAGER_H
#include "TGSDK.h"
#include "TuPureSDK.h"
#include "callback.h"
#include "config.h"
#include "hid_engine.h"
#include "hidinterfaceimpl.h"

/**
 * 写数据监听,向客户端写数据状态
 * @brief The WriteListener class
 */
class HIDWriteListener : public OnHIDWriteListener {
public:
  void onHIDWriteResult(int progress, long totalProgress,
                        bool completed) override;

  void onHIDWriteFailed(int errorCode, std::string errMsg) override;
};

/**
 * HID 读文件监听,来自客户端的文件流
 * @brief The ReadFileListener class
 */
class ReadFileListener :  public OnHIDReadFileListener {
public:
  void onHIDReadFileResult(std::string filePath, std::string tag, int progress,
                           long maxProgress, bool completed) override;

  void onHIDReadFileFailed(int errorCode, std::string errMsg) override;
};

/**
 * 读取随机文件
 * @brief The ReadRandomFileListener class
 */
class ReadRandomFileListener : public OnHIDReadRandomFileListener {
public:
  void onHIDReadRandomFileResult(std::string filePath, bool completed) override;

  void onHIDReadRandomCancel(std::string filePath) override;

  void onHIDReadRandomPause(bool paused) override;

  void onHIDReadRandomFailed(int errorCode, std::string errMsg) override;
};

/**
 * 写随机文件回调
 */
class WriteRandomFileListener : public OnHIDWriteRandomFileListener {
public:
  void onHIDWriteRandomStart();
  void onHIDWriteRandomFailed(int errorCode, std::string errMsg);
  void onHIDWriteRandomCompleted();
};

/**
 * HID错误
 * @brief The OnErrorListener class
 */
class OnErrorListener :  public OnHIDErrorListener {
public:
  void onHIDError(int errorCode, std::string errMsg) override;
};

/**
 * HID 帧数据
 * @brief The FrameListener class
 */
class FrameListener : public OnHIDFrameListener {
public:
  void onHIDFrameFrame(char cmd, const std::vector<char> &data,
                       std::string tag) override;

  void onHIDFrameFailed(int errorCode, std::string errMsg) override;
};

class StopDataListener : public OnHIDStopDataListener {
public:
  void onHIDStopData() override;
};

class TGSDKManager {
private:
  bool m_bDevConn = false;
  std::string m_HidDownloadPath;

  // 改用智能指针管理 hid_engine 引擎
  std::unique_ptr<hid_engine> m_pHidEngine;

  // 锁对象
  std::mutex m_gMutex;
  std::mutex g_MutexVar;

  // 监听HID总线错误
  std::shared_ptr<OnErrorListener> m_OnErrorListener;
  // 监听下位机帧数据
  std::shared_ptr<FrameListener> m_FrameListener;
  // 读文件监听
  std::shared_ptr<ReadFileListener> m_ReadFileListener;
  // 停止HID回调
  std::shared_ptr<StopDataListener> m_StopDataListener;
  // 写数据回调
  std::shared_ptr<HIDWriteListener> m_WriteListener;
  // 写随机文件
  std::shared_ptr<WriteRandomFileListener> m_WriteRandomFileListener;
  // 读随机文件
  std::shared_ptr<ReadRandomFileListener> m_ReadRandomFileListener;

  // 条码数组
  BARCODE_BEAN **list = nullptr;
  // 条码数组长度
  int arraySize = 0;

  static TG_OnHIDListener m_TG_OnHIDListener;
  static TG_OnFrameListener m_TG_OnFrameListener;
  static TG_OnReadFileListener m_TG_ReadFileListener;
  static TG_WriteFileListener m_TG_WriteFileListener;
  static TG_WriteRandomFileListener m_TG_WriteRandomFileListener;
  static TG_ReadRandomFileListener m_TG_ReadRandomFileListener;

  // 报码回调
  static TUP_Barcode_Result_Callback m_TUPBarCodeResultCallback;
  static TUP_Resolution_Callback m_TUPResolutionCallback;

private:
  int InitHID();

private:
  int WriteACK(const char *data, int size, const char *tag, int tagSize);

public:
  TGSDKManager();
  ~TGSDKManager();

  // 初始化
  int Init(TG_OnHIDListener l1, TG_OnFrameListener l2,
           TG_OnReadFileListener l3);

  // 反初始化
  int UInit();

  // 打开设备
  int OpenDev(unsigned short vendor_id, unsigned short product_id);

  // 打开摄像头
  int OpenCamera();

  // 关闭摄像头
  int CloseCamera();

  // 开启解码
  int StartDecode(TUP_Barcode_Result_Callback fnBarcodeResultCallback);

  // 停止解码
  int StopDecode();

  // 设置条码模式
  int SetBarMode(int splitMode, int appendSplitMode);

  // 条码码与码之间的延迟
  int SetBarCodeDelay(float delay);

  // 设置自动清理
  int SetAutoClear(float time);

  // 关闭自动清理
  int StopAutoClear();

  // 设置码与码之间的回车个数
  int SetEnterCount(int count);

  // 设置追加字符
  int SetAppendChars(int pos, char *chars);

  // 追溯码分割
  int SetTraceCodeSplit(int traceCodeSplit);

  // 语音播报模式
  int SetVoiceSpeechMode(int voiceSpeechMode);

  // 获取分辨率
  int GetResolution(TUP_Resolution_Callback fnResolutionCallback);

  // 设置分辨率
  int SetResolution(int width, int height);

  // 开启code128
  int EnableCode128();

  // 关闭code128
  int DisableCode128();

  // 开启QR
  int EnableQR();

  // 开启DM
  int EnableDM();

  // 关闭QR
  int DisableQR();

  // 关闭DM
  int DisableDM();

  // 关闭设备
  int CloseDev();

  // 重置默认参数
  int ResetParams();

  // 释放内存
  int mfree();

  // 写文本数据
  int WriteData(const char *data, int size, const char *tag, int tagSize);

  // 写文本数据，异步回调
  void WriteData2(const char *data, int size, const char *tag, int tagSize,
                  TG_WriteFileListener l);
  // 写文件
  void WriteFile(const char *filePath, const char *tag, int tagSize,
                 TG_WriteFileListener l);

  // 写随机文件
  void WriteRandomFile(const char *filePath, int fileExtension,
                       TG_WriteRandomFileListener l);

  // 停止发送数据
  int Stop();

  // 取消写随机文件
  void cancelRandomFile();

  // 写随机文件暂停
  void pause();

  // 恢复写随机文件
  void resume();

  // 停止写随机文件
  void stopRandomFile();

  // 接收下位机 HID 数据
  void hidHidRecFrame(std::string tag, std::string msg);

  // 接收hid数据错误
  void hidFrameError(int errorCode, std::string errMsg);

  // 监听hid总线错误
  void hidListenerError(int errorCode, std::string errMsg);

  // 写数据进度
  void hidWriteDataSuccess(int progress, long totalProgress, bool completed);

  // 写数据发生错误
  void hidWriteDataError(int errorCode, std::string errMsg);

  // 读文件监听
  void hidFileReceive(std::string filePath, std::string tag, int progress,
                      long maxProgress, bool complted);
  // 读文件错误监听
  void hidReadFileError(int errorCode, std::string errMsg);

  // 写随机文件开始
  void hidWriteRandomFileStart();

  // 写随机文件失败
  void hidWriteRandomFileFailed(int errorCode, std::string errMsg);

  // 写随机文件完成
  void hidWriteRandomFileCompleted();

  // 读下位机随机写文件
  void hidReadRandomFileResult(std::string filePath, bool completed);

  // 读下位机随机文件取消
  void hidReadRandomCancel(std::string filePath);

  // 读下位机随机文件暂停
  void hidReadRandomPause(bool paused);

  // 读取下位机随机文件错误
  void hidReadRandomFailed(int errorCode, std::string errMsg);

  // 停止发送数据
  void hidStopData();
};

#endif // TGSDKMANAGER_H
